home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / telecomm / sticpsrc.lzh / SOURCE.ARC / FINGCLI.C < prev    next >
C/C++ Source or Header  |  1989-01-11  |  6KB  |  267 lines
  1.  
  2. /*
  3.  *
  4.  *    Finger support...
  5.  *
  6.  *    Finger client routines.     Written by Michael T. Horne - KA7AXD.
  7.  *    Copyright 1988 by Michael T. Horne, All Rights Reserved.
  8.  *    Permission granted for non-commercial use and copying, provided
  9.  *    that this notice is retained.
  10.  *
  11.  */
  12.  
  13. #include <stdio.h>
  14. #ifdef MSC
  15. #include <sys/types.h>
  16. #endif
  17. #include "global.h"
  18. #include "mbuf.h"
  19. #include "timer.h"
  20. #include "internet.h"
  21. #include "icmp.h"
  22. #include "netuser.h"
  23. #include "tcp.h"
  24. #include "finger.h"
  25. #include "session.h"
  26.  
  27. extern char    badhost[],
  28.         hostname[];
  29.  
  30. /*
  31.  *
  32.  *    Open up a socket to a remote (or the local) host on its finger port.
  33.  *
  34.  */
  35.  
  36. int
  37. dofinger(argc,argv)
  38. int    argc;
  39. char    *argv[];
  40. {
  41.     void        f_state(),
  42.             fingcli_rcv();
  43.     struct session    *s;
  44.     struct tcb    *tcb;
  45.     struct socket    lsocket,
  46.             fsocket;
  47.     struct finger    *finger, *alloc_finger();
  48.     char        *host;
  49.  
  50.     lsocket.address = ip_addr;
  51.     lsocket.port = lport++;
  52.  
  53. /*
  54.  *    Extract user/host information.    It can be of the form:
  55.  *
  56.  *    finger user,            # finger local user
  57.  *    finger user@host,        # finger remote user
  58.  *    finger @host            # finger host (give system status)
  59.  *
  60.  */
  61.     if ((finger = alloc_finger()) == NULLFING)
  62.         return(1);
  63.  
  64.     if ((host = index(argv[1], '@')) == NULLCHAR) {
  65.         fsocket.address = ip_addr;    /* no host, use local */
  66.         if ((finger->user = malloc(strlen(argv[1]) + 3)) == NULLCHAR) {
  67.             free_finger(finger);
  68.             return(1);
  69.         }
  70.         strcpy(finger->user, argv[1]);
  71.         strcat(finger->user, "\015\012");
  72.     }
  73.     else {
  74.         *host++ = '\0';        /* null terminate user name */
  75.         if (*host == '\0') {    /* must specify host */
  76.             printf("%s: no host specified\n", argv[0]);
  77.             free_finger(finger);
  78.             return(-1);
  79.         }
  80.         if ((fsocket.address = resolve(host)) == 0) {
  81.             printf("%s: ", argv[0]);
  82.             printf(badhost, host);
  83.             free_finger(finger);
  84.             return(1);
  85.         }
  86.         if ((finger->user = malloc(strlen(argv[1])+3))==NULLCHAR) {
  87.             free_finger(finger);
  88.             return 1;
  89.         }
  90.         strcpy(finger->user, argv[1]);
  91.         strcat(finger->user, "\015\012");
  92.     }
  93.  
  94.     fsocket.port = FINGER_PORT;        /* use finger wnp */
  95.  
  96.     /* Allocate a session descriptor */
  97.     if ((s = newsession()) == NULLSESSION){
  98.         printf("Too many sessions\n");
  99.         free_finger(finger);
  100.         return 1;
  101.     }
  102.     current = s;
  103.     s->cb.finger = finger;
  104.     finger->session = s;
  105.  
  106.     if (host == NULLCHAR)                /* if no host specified */
  107.         host = hostname;        /* use local host name */
  108.     if ((s->name = malloc(strlen(host)+1)) != NULLCHAR)
  109.         strcpy(s->name, host);
  110.  
  111.     s->type = FINGER;
  112.     s->parse = (int (*)()) NULL;
  113.  
  114.     tcb = open_tcp(&lsocket, &fsocket, TCP_ACTIVE, 0,
  115.      fingcli_rcv, (void (*)()) 0, f_state, 0, (int *) finger);
  116.  
  117.     finger->tcb = tcb;
  118.     tcb->user = (char *)finger; /* cast into what belonges there */
  119.     go();
  120.     return 0;
  121. }
  122.  
  123. /*
  124.  *    Allocate a finger structure for the new session
  125.  */
  126. struct finger *
  127. alloc_finger()
  128. {
  129.     struct finger *tmp;
  130.  
  131.     if ((tmp = (struct finger *) malloc(sizeof(struct finger))) == NULLFING)
  132.         return(NULLFING);
  133.     tmp->session = NULLSESSION;
  134.     tmp->user = (char *) NULL;
  135.     return(tmp);
  136. }
  137.  
  138. /*
  139.  *    Free a finger structure
  140.  */
  141. int
  142. free_finger(finger)
  143. struct finger *finger;
  144. {
  145.     if (finger != NULLFING) {
  146.         if (finger->session != NULLSESSION)
  147.             freesession(finger->session);
  148.         if (finger->user != (char *) NULL)
  149.             free(finger->user);
  150.         free(finger);
  151.     }
  152.     return 0;
  153. }
  154.  
  155. /* Finger receiver upcall routine */
  156. void
  157. fingcli_rcv(tcb, cnt)
  158. register struct tcb    *tcb;
  159. int16            cnt;
  160. {
  161.     struct mbuf    *bp;
  162.     char        *buf;
  163.  
  164.     /* Make sure valid finger session */
  165.     if ((struct finger *) tcb->user == NULLFING) {
  166.         return;
  167.     }
  168.  
  169.     /* Hold output if we're not the current session */
  170.     if (mode != CONV_MODE || current == NULLSESSION
  171.         || current->type != FINGER
  172.         || current->cb.finger != (struct finger *)tcb->user)
  173.         return;
  174.  
  175.     if (recv_tcp(tcb, &bp, cnt) > 0)
  176.         while (bp != NULLBUF) {
  177.             buf = bp->data;
  178.             while(bp->cnt--) {
  179.                 switch (*buf) {
  180.                     case '\012':
  181.                         break;
  182.                     case '\015':
  183.                         fputs("\n", stdout);
  184.                         break;
  185. #ifdef MSDOS
  186.                     case '\032': /* CPMEOF (dont hang doubledos!) */
  187.                         break;
  188. #endif
  189.                     default:
  190.                         fputc(*buf, stdout);
  191.                         break;
  192.                 }
  193.                 if(current->record != NULLFILE)
  194.                     fputc(*buf,current->record);
  195.                 buf++;
  196.             }
  197.             bp = free_mbuf(bp);
  198.         }
  199.     fflush(stdout);
  200. }
  201.  
  202. /* State change upcall routine */
  203. void
  204. f_state(tcb,old,new)
  205. register struct tcb    *tcb;
  206. char            old,        /* old state */
  207.             new;        /* new state */
  208. {
  209.     struct finger    *finger;
  210.     char        notify = 0;
  211.     extern char    *tcpstates[];
  212.     extern char    *reasons[];
  213.     extern char    *unreach[];
  214.     extern char    *exceed[];
  215.     struct mbuf    *bp;
  216.  
  217.     finger = (struct finger *)tcb->user;
  218.  
  219.     if(current != NULLSESSION && current->type == FINGER)
  220.         notify = 1;
  221.  
  222.     switch(new){
  223.  
  224.     case CLOSE_WAIT:
  225.         if(notify)
  226.             printf("%s\n",tcpstates[new]);
  227.         close_tcp(tcb);
  228.         break;
  229.  
  230.     case CLOSED:    /* finish up */
  231.         if(notify) {
  232.             printf("%s (%s", tcpstates[new], reasons[tcb->reason]);
  233.             if (tcb->reason == NETWORK){
  234.                 switch(tcb->type){
  235.                 case DEST_UNREACH:
  236.                     printf(": %s unreachable",unreach[tcb->code]);
  237.                     break;
  238.                 case TIME_EXCEED:
  239.                     printf(": %s time exceeded",exceed[tcb->code]);
  240.                     break;
  241.                 }
  242.             }
  243.             printf(")\n");
  244.             cmdmode();
  245.         }
  246.         if(finger != NULLFING)
  247.             free_finger(finger);
  248.         del_tcp(tcb);
  249.         break;
  250.     case ESTABLISHED:
  251.         if (notify) {
  252.             printf("%s\n",tcpstates[new]);
  253.             printf("[%s]\n", current->name);
  254.         }
  255.         bp = qdata(finger->user, (int16) strlen(finger->user));
  256.         send_tcp(tcb, bp);
  257.         break;
  258.  
  259.     default:
  260.         if(notify)
  261.             printf("%s\n",tcpstates[new]);
  262.         break;
  263.     }
  264.     fflush(stdout);
  265. }
  266.  
  267.